﻿/*----------------------------------------------------------------------------------------
*
*  Copyright 2019, Gao Hai Hui, <fromzeropoint@126.com>.  All rights reserved.
*  https://gitee.com/helloworldghh/xoskit.git
*  Use of this source code is governed by a MIT license
*  that can be found in the License file.
*
----------------------------------------------------------------------------------------*/
#ifndef __XOSKIT_XOS_CORE_XOS_STL_SRC_MEM_POOL_MEM_POOL_ITEM_H__
#define __XOSKIT_XOS_CORE_XOS_STL_SRC_MEM_POOL_MEM_POOL_ITEM_H__

#include "fake_lock.h"
#include "local_pool.h"
#include "mem_pool.h"
#include "auto_list.h"
#include "xos_group.h"
#include "xos_list.h"
#include "xos_map.h"
#include <string>
#include <list>
#include <map>

namespace xos_stl
{

    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 
    // mem_item, 所有内存池结点都从它继承出来
	// 

	template< class T, class PoolLock = fake_lock, class ListLock = fake_lock, class PoolListLock = fake_lock, class IntMapLock = fake_lock, class StrMapLock = fake_lock,
		class AutoListLock = fake_lock, class LocalPoolLock = fake_lock, class LocalPoolListLock = fake_lock >
    class mem_item
    {
    public:
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // 
		typedef AutoListLock AUTO_LIST_LOCK;
		typedef PoolListLock POOL_LIST_LOCK;
		typedef IntMapLock INT_MAP_LOCK;
		typedef StrMapLock STR_MAP_LOCK;
		typedef PoolLock POOL_LOCK;
		typedef ListLock LIST_LOCK;
		
		typedef local_pool< T, LocalPoolLock, LocalPoolListLock > LOCAL_POOL;
		typedef mem_pool< T, POOL_LOCK, POOL_LIST_LOCK > POOL;

		typedef xos_map< std::string, T, STR_MAP_LOCK > STR_MAP;
		typedef typename STR_MAP::const_iterator CONST_STR_ITER;
		typedef typename STR_MAP::iterator STR_ITER;

		typedef xos_map< int, T, INT_MAP_LOCK > INT_MAP;
		typedef typename INT_MAP::const_iterator CONST_INT_ITER;
		typedef typename INT_MAP::iterator INT_ITER;

		typedef auto_list< T, AUTO_LIST_LOCK > AUTO_LIST;
		typedef typename AUTO_LIST::const_iterator CONST_AUTO_ITER;
		typedef typename AUTO_LIST::iterator AUTO_ITER;

		typedef xos_list< T, LIST_LOCK > LIST;
		typedef typename LIST::const_iterator CONST_ITER;
		typedef typename LIST::iterator ITER;

    public:
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // 
        mem_item()
		{
		}
        ~mem_item()
		{
		}

	public:
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // 
		static T * get_item_from_local_pool( bool bLock )
		{
			return T::local_pool()->get_item( bLock );
		}
		static void put_back_to_local_pool( T * pT, bool bLock )
		{
			T::local_pool()->put_item( pT, bLock );
		}
		static T * get_item_from_pool( bool bLock )
		{
			return T::pool()->get_item( bLock );
		}
		static void put_back_to_pool( T * pT, bool bLock )
		{
			T::pool()->put_item( pT, bLock );
		}
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // 
        static int init_pool()
        {
            int ret = 0;
            POOL ** ppData = 0;
            T::get_addr( &ppData, 0 );
            if( ppData )
            {
                ret = xos_stl::init_pool( *ppData );
            }
            return ret;
        }
        static int init_list()
        {
            int ret = 0;
            LIST ** ppData = 0;
            T::get_addr( 0, &ppData );
            if( ppData )
            {
                ret = xos_stl::init_list( *ppData );
            }
            return ret;
        }
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // 
        static int term_pool()
        {
            int ret = 0;
            POOL ** ppData = 0;
            T::get_addr( &ppData, 0 );
            if( ppData )
            {
                ret = xos_stl::term_pool( *ppData, true );
            }
            return ret;
        }
        static int term_list()
        {
            int ret = 0;
            LIST ** ppData = 0;
            T::get_addr( 0, &ppData );
            if( ppData )
            {
                ret = xos_stl::term_list( *ppData, true );
            }
            return ret;
        }
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // 
        static int init_all()
        {
            int ret = 0;
            if( 0 == ret )
            {
                ret = init_pool();
            }
            if( 0 == ret )
            {
                ret = init_list();
            }
            if( 0 == ret )
            {
                ret = T::static_user_init();
            }
            return ret;
        }
        static int term_all()
        {
            int ret = 0;
            if( 0 == ret )
            {
                ret = T::static_user_term();
            }
            if( 0 == ret )
            {
                ret = term_list();
            }
            if( 0 == ret )
            {
                ret = term_pool();
            }
            return ret;
        }
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // 
        static POOL * pool()
        {
            POOL ** ppData = 0;
            T::get_addr( &ppData, 0 );
            return *ppData;
        }
        static LIST * list()
        {
            LIST ** ppData = 0;
            T::get_addr( 0, &ppData );
            return *ppData;
        }
        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // 
        static int static_user_init()
        {
            int ret = 0;
            return ret;
        }
        static int static_user_term()
        {
            int ret = 0;
            return ret;
        }
    };

} // xos_stl

#endif // __XOSKIT_XOS_CORE_XOS_STL_SRC_MEM_POOL_MEM_POOL_ITEM_H__
